#! /bin/bash
#######################################
# Script monitor.sh ecrit par max-k : [max-kATpostDOTcom]
# Version 0.1
# Changelog :
# -Ajout de la purge des fichiers de log
####DESCRIPTION :
# Ce script permet de controler le bon fonctionnement
# materiel et logiciel d'un serveur GNU/Linux.
# Il peut s'assurer de la bonne marche de services mysql,
# surveiller l'espace disque et la quantite de memoire
# vive disponibles, le bon etat des disques durs ou encore
# le bon fonctionnement d'un serveur secondaire.
# Vous serez averti par sms, par mail ou encore par une impression
# si le moidre probleme survient.
# Ce script effectue egalement une sauvegarde quotidienne en creant un tar.gz
# et permet la conservation de ces sauvegardes sur un nombre parametrable
# de jours.
# Il propose aussi de sauvegarder de la meme maniere des dumps mysql.
# Les fichiers de log de sauvegarde, utilises pour l'envoi de mail ou
# l'impression seront egalement conserves pendant la meme periode que
# les sauvegardes.
####PREREQUIS :
#smartmontools : [http://smartmontools.sourceforge.net/]
#wput : [http://wput.sourceforge.net/]
#curl : [http://curl.haxx.se/]
#lftp : [http://lftp.yar.ru/]
#mysql-clients : [http://www-fr.mysql.com/]
#L'envoi d'impression necessite cups, ghost0script et gsfonts.
#L'envoi de mail necessite un client smtp compatible sendmail.
#(Il va de soi que ce client doit etre configure comme il se doit)
####INSTRUCTIONS :
# -Assurez-vous d'installer les dependances necessaires a
# l'execution de ce script avant toute utilisation.
# -Veillez egalement a parametrer correctement toutes les
# variables ci-dessous en suivant les indications.
# -Ce script doit etre execute en tant que root.
# -Idealement il peut etre lance regulierement a l'aide
# d'un planificateur comme cron (cf. /etc/crontab).
####LICENCE : GPL V3
# http://www.gnu.org/licenses/gpl-3.0.html
# traduction fr : http://www.rodage.org/gpl-3.0.fr.html
######################################


#####DECLARATION DES VARIABLES#####

#-------parametres envoi de sms-------#
#
# Ce script utilise le service d'envoi de sms en ligne fourni
# par envoyersms.org, il peut egalement utiliser rapidosms.com.
# Indiquez ci-dessous vos noms d'utilisateurs et mots de passe
# correspondants au service choisi ainsi que le nom du service.
service_sms=envoyersms.org #alternative : rapidosms.com
login_sms=""
pass_sms=""
verifier_credit_restant=false #mettre a true pour verifier le credit
# sms restant avant d'envoyer un sms.

#-numeros expediteur et destinataire-#
#
# Ici, vous pouvez definir le numero du destinataire des sms mais
# aussi celui qui s'affichera comme etant l'expediteur de ce sms.
destinataire=336........
expediteur=336........

#-----espaces disques a verifier-----#
#
# Ici, vous pouvez definir les points de montages des partitions
# pour lequelles vous souhaitez verifier l'espace disque.
# Pour plusieurs volumes, separez les par des espaces.
# Vous pouvez aussi definir a partir de quel pourcentage d'utilisation
# des volumes vous souhaitez etre avertis.
volumes="/var /" #Ex. "/var/www /home".
pourcentage_espace_disque_critique=80

#-------disques durs a verifier------#
#
# Definissez ici le (ou les) disque(s) dur(s) que vous souhaitez
# verifier avec la fonction verification_disques qui utilise SMART.
# Vous devez vous assurer que vos disques disposent de cette fonctionnalite.
# Pour plusieurs disques, separez les par des espaces.
disques_durs="/dev/sda" #Ex. "/dev/hda /dev/hdb".

#-----seuil d'alerte memoire vive----#
#
# Definissez ici le seuil de memoire vive disponible en dessous duquel
# vous souhaitez recevoir un sms d'alerte (en %).
seuil_alerte_memoire_vive=20 #Le pourcentage est analyse hors mise en cache
# afin que le resultat ne soit pas perturbe par les fonctions de swap en memoire vive.

#--------parametres sauvegarde-------#
#
# Definisez ici tous les parametres necessaires a la fonction sauvegarde
# si vous souhaitez l'utiliser.
# Les repertoires a sauvegarder doivent etre separes pas des espaces.
# La variable nombre_a_conserver designe le nombre de sauvegardes qui
# seront stockees en permanence dans le repertoire de stockage. On ne
# conservera que les n plus recentes.
# Cela vaud egalement pour le stockage sur ftp.
repertoire_sauvegarde=/root/backup
repertoires_a_sauvegarder="/etc /srv/http/ocsreports /srv/http/glpi /srv/http/elvenet /srv/http/elvenet-new /srv/http/phpMyAdmin3.0.1.1"
nombre_a_conserver=1
utiliser_ftp=false # Mettez la valeur true pour utiliser les fonctions ftp.
utiliser_smb=true # Mettez la valeur false pour utiliser les fonctions smb
#heure_sauvegarde=17
#minute_sauvegarde=30
# Pour l'instant le script ne prevoit que la possibilite de faire une
# sauvegarde complete quotidienne.

#--------parametres envoi smb-------#
#
# Ici, vous pouvez configurer les parametres necessaires au bon
# fonctionnement de la fonction envoi_smb si vous comptez l'utiliser. 
login_smb=backupLV
pass_smb=backLV2008
dom_smb=es
hote_smb=msg1 # Pensez a remplir le fichier /etc/hosts si vous utilisez
# un nom netbios.
partage_smb=intranet
point_de_montage=/mnt/lan
sous_repertoire=elvenet2 # Ce parametre est facultatif, il vous permet
# d'utiliser un sous repertoire dans le partage, s'il est vide, cette option
# est ignoree.

#--------parametres envoi ftp--------#
#
# Ici, vous pouvez configurer les parametres necessaires au bon
# fonctionnement des fonctions envoi_ftp et suppression_ftp si vous comptez
# les utiliser.
login_ftp=
pass_ftp=
hote_ftp=
repertoire_ftp=backup # facultatif, ignore si vide.

#--------parametres envoi de mail--------#
#
#Ici, vous pouvez specifier les destinataires des differents messages
destinataires_des_messages="max-k hutinr pcr"

#-----parametres envoi impression-----#
#
# Ici, vous pouvez choisir l'imprimante cible, vous pouvez lister les
# imprimantes installees avec la commande lpq.
# Si vous ne mettez rien, l'imprimante par defaut sera utilisee.
imprimante=IBM_INFO

#----parametres serveur secondaire---#
#
# Ici, vous pouvez configurer les parametres necessaires au bon
# fonctionnement de la fonction test_serveur_secondaire si vous comptez
# l'utiliser.
# Vous pouvez renseigner la variable serveur_secondaire avec un nom d'hote
# ou avec une adresse ip.
serveur_secondaire=msg1

#----------parametres mysql----------#
#
# Ici, vous pouvez configurer les parametres necessaires au bon
# fonctionnement de la fonction tests_mysql si vous comptez
# l'utiliser. L'utilisateur doit avoir les droit d'acces a la
# base mysql (base de donees par defaut).
hote_mysql=localhost #vous pouvez mettre une adresse IP le cas echeant
user_mysql=max-k
pass_mysql=fuckyou22
bases_a_sauvegarder="glpi ocsweb qualite telephone phpmyadmin elvenet"

#------parametres de journalisation-------#
#
# La journalisation permet de ne pas etre avertis 15 fois
# du meme probleme lorsque le script est lance par cron.
repertoire_de_travail=/root/monitoring # Aussi utilise par la suppression sur ftp.
# Les fichiers de journalisation ne sont pas destines a etre
# consultes par l'utilisateur mais uniquement par le script.
# Il est donc preferable de les stocker separement afin de ne pas
# encombrer le repertoire de sauvegarde.

#--------parametres predefinis--------#
#
# Ces variables se definissent automatiquement, vous n'avez donc
# pas a les modifier.
nom_serveur=$(uname -n)
prefix="http://www."
url_api=${prefix}${service_sms}/exe/api.php

#####EXECUTION PERSONNALISEE#####

# Vous pouvez, en utilisant les variables suivantes, inhiber certaines parties
# du script qui ne correspondent pas a vos besoins.
# Par defaut, tout est execute. Pour empecher l'execution d'une partie du
# script, il vous suffit de decommenter la ligne correspondante.
#
#VERIFICATION_ESPACE_DISQUE=false
#VERIFICATION_ETAT_DISQUES=false
#VERIFICATION_MEMOIRE_VIVE=false
#SAUVEGARDE=false
#TEST_SERVEUR_SECONDAIRE=false
#TEST_MYSQL=false
#JOURNALISATION=false #(Ne faites pas ï¿½a si le script est lance par cron.)
ENVOI_DE_SMS=false #(Ne faites pas ca. Juste pour les tests, sauf si vous activez l'envoi de mail.)
#ENVOI_DE_MAIL=false #(Ne faites pas ca. Juste pour les tests, sauf si vous activez l'envoi de sms.)
ENVOI_IMPRESSION=false #(N'activer cette fonction que si cela s'avere vraiment necessaire.)

#####DEFINITION DES FONCTIONS#####

fin_du_script() {
# Cette fonction met fin au script en prenant soin de supprimer
# le fichier de tracage d'execution.
rm /root/monitoring/monitor.x.pid
exit
}

verification_jour_mois() {
jour=$(date +%A)
mois=$(date +%B)
if [ $mois = "decembre" ]; then
	mois="decembre"
fi
if [[ ! ( $jour = "lundi" ) || ( $jour = "mardi" ) || ( $jour = "mercredi" ) || ( $jour = "jeudi" ) || ( $jour = "vendredi" ) || ( $jour = "samedi" ) || ( $jour = "dimanche" ) ]]; then
	case $jour in
	Monday)
		jour="Lundi"
		;;
	Thuesday)
		jour="Mardi"
		;;
	Wednesday)
		jour="Mercredi"
		;;
	Thursday)
		jour="Jeudi"
		;;
	Friday)
		jour="Vendredi"
	esac
	case $mois in
	January)
		mois="Janvier"
		;;
	February)
		mois="Fevrier"
		;;
	March)
		mois="Mars"
		;;
	April)
		mois="Avril"
		;;
	May)
		mois="Mai"
		;;
	June)
		mois="Juin"
		;;
	July)
		mois="Juillet"
		;;
	August)
		mois="Aout"
		;;
	September)
		mois="Septembre"
		;;
	October)
		mois="Octobre"
		;;
	November)
		mois="Novembre"
		;;
	December)
		mois="Decembre"
		;;
	esac
fi
export date_full="${jour} $(date +%d) ${mois} $(date +%Y)"
}

verification_root() {
# Cette fonction s'assure que le script ai bien ete lance en tant que root.
if [ ! $(id -u) = 0 ]; then
	echo "Veuillez executer ce script en tant que root" && exit
fi
}

verification_connectivite() {
ping -c 1 -q www.google.fr > /dev/null
if [ $? = 2 ]; then
	fin_du_script
fi
}

verification_repertoire_de_travail() {
# Cette fonction verifie que le repertoire de travail existe bien.
if [ ! -d $repertoire_de_travail ]; then
	mkdir $repertoire_de_travail
fi
}

verification_repertoire_de_sauvegarde() {
# Cette fonction verifie que le repertoire de sauvegarde existe bien.
if [ ! -d $repertoire_sauvegarde ]; then
	mkdir $repertoire_sauvegarde
fi
}

verification_credit_restant() {
# Cette fonction verifie le credit de sms restant sur le compte. Si ce chiffre
# atteint un niveau fatidique, un message d'alerte est genere.
message_credit=""
credit=`curl -s -d "login=$login&pass=$pass&action=credit" $url_api | awk '{print $2}'`
case $credit in
0)
	if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
		sortie=${repertoire_de_travail}/last_log.log
		echo "#monitoring - avertissement# Plus de credit SMS" > $sortie
		echo "${date_full}." >> $sortie
		echo "Message envoye par ${nom_serveur}." >> $sortie
		echo "Le credit SMS pour $login_sms sur ${prefix}${service_sms} est epuise." >> $sortie
		if [ -z $ENVOI_DE_MAIL ]; then
			envoi_de_mail $sortie
		fi
		if [ -z $ENVOI_IMPRESSION ]; then
			envoi_impression $sortie
		fi
	else
		return 1
	fi
	;;
1)
	if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
		sortie=${repertoire_de_travail}/last_log.log
		echo "#monitoring - avertissement# Credit SMS quasiment epuise" > $sortie
		echo "${date_full}." >> $sortie
		echo "Message envoye par ${nom_serveur}." >> $sortie
		echo "Le credit SMS restant pour $login_sms sur ${prefix}${service_sms} est quasiment epuise : 1 restant." >> $sortie
		if [ -z $ENVOI_DE_MAIL ]; then
			envoi_de_mail $sortie
		fi
		if [ -z $ENVOI_IMPRESSION ]; then
			envoi_impression $sortie
		fi
	fi
	message_credit=" Il ne reste plus de sms sur le compte de $login."
	;;
16)
	if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
		sortie=${repertoire_de_travail}/last_log.log
		echo "#monitoring - avertissement# Credit SMS proche de l\'epuisement" > $sortie
		echo "${date_full}." >> $sortie
		echo "Message envoye par ${nom_serveur}." >> $sortie
		echo "Le credit SMS restant pour $login_sms sur ${prefix}${service_sms} est proche de l\'epuisement : 15 restants." >> $sortie
		if [ -z $ENVOI_DE_MAIL ]; then
			envoi_de_mail $sortie
		fi
		if [ -z $ENVOI_IMPRESSION ]; then
			envoi_impression $sortie
		fi
	fi
	message_credit=" Il ne reste plus que 15 sms sur le compte de $login."
	;;
*)
	;;
esac
}

envoi_de_sms() {
# Cette fonction envoie par sms le message fourni en parametre ainsi que le
# nombre de sms restant.
if [ ! -f ${repertoire_de_travail}/$2.txt ]; then
	debut_commande="curl -s -d \"login=${login_sms}&pass=${pass_sms}&msg=${1}"
	fin_commande="&dest=${destinataire}&exp=${expediteur}\" $url_api > /dev/null"
	if [ $verifier_credit_restant = "true" ]; then
		verification_credit_restant
		if [ $? = 1 ]; then
			fin_du_script
		fi
		if [ ! -z $message_credit ]; then
			commande="${debut_commande}${message_credit}${fin_commande}"
		else
			commande="$debut_commande Credit sms restant : ${credit}.${fin_commande}"
		fi
	else
		commande="${debut_commande}${fin_commande}"
	fi
	eval $commande
fi
}

envoi_de_mail() {
# Cette fonction envoie par mail le fichier fourni en parametre aux destinataires sepcifies plus haut.
# La premiere ligne devient le sujet du message.
if [ ! -f ${repertoire_de_travail}/$2.txt ]; then
	tail -n +2 $1 | mail -s "$(head -n 1 $1)" $destinataires_des_messages
fi
}

envoi_imprimante() {
# Cette fonction imprime le message fourni en parametre sur l'imprimante specifiee plus haut.
# L'imprimante par defaut est utilisee si aucune imprimante n'est specifiee.
if [[ ( -z $2 || ! -f ${repertoire_de_travail}/$2.txt ) ]]; then
	if [ -z $imprimante ]; then
		lpr $1
	else
		lpr -P $imprimante $1
	fi
fi
}

journalisation() {
# La journalisation permet d'eviter que si le script s'execute en cron et qu'un
# probleme survient, vous soyez averti du probleme a chaque execution du script.
# Des lors que vous aurez ete prevenu une fois, cela ne se reproduira plus.
if [ -z $JOURNALISATION ]; then
	echo "$(date +%d/%m/%y) : $2" >> ${repertoire_de_travail}/${1}.txt
fi
}

dejournalisation() {
# La dejournalisation permet de lever la restriction d'avertissement lorsqu'un
# probleme a ete regle afin que vous soyez avertis la prochaine fois.
if [ -f $repertoire_de_travail/${1}.txt ]; then
	if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
		sortie=${repertoire_de_travail}/last_log.log
		echo "#monitoring - information# Retablissement du service $1 sur $nom_serveur" > $sortie
		echo "${date_full}." >> $sortie
		echo "Le dernier monitoring indique que tout est rentre dans l'ordre." >> $sortie
		if [ -z $ENVOI_DE_MAIL ]; then
			envoi_de_mail $sortie
		fi
		if [ -z $ENVOI_IMPRESSION ]; then
			envoi_impression $sortie
		fi
	fi
		rm $repertoire_de_travail/${1}.txt
fi
}

verification_espace_disque() {
# Cette fonction verifie l'espace disque disponible pour les volumes selectionnes.
declare -i compteur=1
while [ ! $compteur = $# ]; do
	espace_disque=$(df -h `eval echo \$$compteur` | tail -n 1 | awk '{print $4]')
	pourcentage_espace_disque=$(df -h `eval echo \$$compteur` | tail -n 1 | awk '{print $5}')
	declare -i espace_disque=${espace_disque%%%}
	if [ $pourcentage_espace_disque -ge $pourcentage_espace_disque_critique ]; then
		if [[ ( -z $ENVOI_DE_MAIL || $ENVOI_IMPRESSION ) ]]; then
			sortie=${repertoire_de_travail}/last_log.log
			echo "#monitoring - avertissement# Espace disque faible sur $nom_serveur" > $sortie
			echo "${date_full}." >> $sortie
			echo "L\'espace disque restant est de $pourcentage_espace_disque sur le volume $(eval echo \$$compteur), soit ${espace_disque}." >> $sortie
			if [ -z $ENVOI_DE_MAIL ]; then
				envoi_de_mail $sortie $FUNCNAME
			fi
			if [ -z $ENVOI_IMPRESSION ]; then
				envoi_impression $sortie $FUNCNAME
			fi
		fi
		message="$nom_serveur : espace disque insuffisant sur le volume $(eval echo \$$compteur)."
		if [ -z $ENVOI_DE_SMS ]; then
			envoi_de_sms "$message" $FUNCNAME
		fi
		journalisation $FUNCNAME "$message"
	else
		dejournalisation $FUNCNAME
	fi
	compteur=$(( $compteur + 1 ))
done
}

verification_etat_disques() {
# Cette fonction utilise SMART afin de verifier l'etat des disques durs.
# Si vos disques n'exploitent pas cette technologie, ils seront ignores.
declare -i compteur=1
while [ ! $compteur = $# ]; do
	#test_pas_un_disque=
	if [[ ! ( -z $(smartctl -Hc `eval echo \$$compteur` | grep specify) || -z $(smartctl -Hc `eval echo \$$compteur` | grep lacks) ) ]]; then
		statut_smart=$(smartctl -Hc `eval echo \$$compteur` | head -n 5 | tail -n 1 | awk '{print $6}')
		if [ ! $statut_smart = PASSED ]; then
			if [[ ( -z $ENVOI_DE_MAIL || $ENVOI_IMPRESSION ) ]]; then
				sortie=${repertoire_de_travail}/last_log.log
				echo "#monitoring - avertissement# Disque dur defectueux sur $nom_serveur" > $sortie
				echo "${date_full}." >> $sortie
				echo "SMART revele un dysfonctionnement sur le disque $(eval echo \$$compteur)." >> $sortie
				if [ -z $ENVOI_DE_MAIL ]; then
					envoi_de_mail $sortie $FUNCNAME
				fi
				if [ -z $ENVOI_IMPRESSION ]; then
					envoi_impression $sortie $FUNCNAME
				fi
			fi
			message="$nom_serveur : probleme SMART sur le disque $(eval echo \$$compteur)."
			if [ -z $ENVOI_DE_SMS ]; then
				envoi_de_sms "$message" $FUNCNAME
			fi
			journalisation $FUNCNAME "$message"
		else
			dejournalisation $FUNCNAME
		fi
	fi
	compteur=$(( $compteur + 1 ))
done
}

verification_memoire_vive() {
# Cette fonction controle que le niveau de memoire vive disponible n'atteigne
# pas un niveau plus bas que celui defini a l'avance.
declare -i statut_memoire_vive=`free -m | head -n 3 | tail -n 1 | awk '{print $4}'`
declare -i memoire_vive_totale=`free -m | head -n 2 | tail -n 1 | awk '{print $2}'`
pourcentage_memoire_vive=$(($statut_memoire_vive * 100 / $memoire_vive_totale))
declare -i seuil_alerte_memoire_vive=$seuil_alerte_memoire_vive
if  [ $pourcentage_memoire_vive -lt $seuil_alerte_memoire_vive ]; then
	if [[ ( -z $ENVOI_DE_MAIL || $ENVOI_IMPRESSION ) ]]; then
		sortie=${repertoire_de_travail}/last_log.log
		echo "#monitoring - avertissement# Memoire vive surchargee sur $nom_serveur" > $sortie
		echo "${date_full}." >> $sortie
		echo "Il reste ${statut_memoire_vive}Mo disponibles sur ${memoire_vive_totale}Mo, soit ${pourcentage_memoire_vive}%." >> $sortie
		if [ -z $ENVOI_DE_MAIL ]; then
			envoi_de_mail $sortie $FUNCNAME
		fi
		if [ -z $ENVOI_IMPRESSION ]; then
			envoi_impression $sortie $FUNCNAME
		fi
	fi
	message="$nom_serveur : memoire vive surchargee, moins de ${seuil_alerte_memoire}Mo disponibles (${pourcentage_memoire_vive}%)."
	if [ -z $ENVOI_DE_SMS ]; then
		envoi_de_sms "$message" $FUNCNAME
	fi
	journalisation $FUNCNAME "$message"
else
	dejournalisation $FUNCNAME
fi
}

test_serveur_secondaire() {
# Cette fonction permet de verifier le bon fonctionnement d'un serveur secondaire.
ping $serveur_secondaire -c1 > /dev/null
case $? in
2)
	if [[ ( -z $ENVOI_DE_MAIL || $ENVOI_IMPRESSION ) ]]; then
		sortie=${repertoire_de_travail}/last_log.log
		echo "#monitoring - avertissement# Le serveur distant $serveur_secondaire ne repond pas" > $sortie
		echo "${date_full}." >> $sortie
		echo "Test effectue depuis ${nom_serveur}." >> $sortie
		echo "Echec de la tentative de contact du serveur ${serveur_secondaire}." >> $sortie
		echo "Type d\'erreur : hote inconnu." >> $sortie
		if [ -z $ENVOI_DE_MAIL ]; then
			envoi_de_mail $sortie $FUNCNAME
		fi
		if [ -z $ENVOI_IMPRESSION ]; then
			envoi_impression $sortie $FUNCNAME
		fi
	fi
	message="$nom_serveur : reponse du serveur $serveur_secondaire : hote inconnu."
	if [ -z $ENVOI_DE_SMS ]; then
		envoi_de_sms "$message" $FUNCNAME
	fi
	journalisation $FUNCNAME "$message"
	;;
1)
	if [[ ( -z $ENVOI_DE_MAIL || $ENVOI_IMPRESSION ) ]]; then
		sortie=${repertoire_de_travail}/last_log.log
		echo "#monitoring - avertissement# Le serveur distant $serveur_secondaire ne repond pas" > $sortie
		echo "${date_full}." >> $sortie
		echo "Test effectue depuis ${nom_serveur}." >> $sortie
		echo "Echec de la tentative de contact du serveur ${serveur_secondaire}." >> $sortie
		echo "Type d\'erreur : pas de reponse." >> $sortie
		if [ -z $ENVOI_DE_MAIL ]; then
			envoi_de_mail $sortie $FUNCNAME
		fi
		if [ -z $ENVOI_IMPRESSION ]; then
			envoi_impression $sortie $FUNCNAME
		fi
	fi
	message="$nom_serveur : le serveur $serveur_secondaire ne repond pas."
	if [ -z $ENVOI_DE_SMS ]; then
		envoi_de_sms "$message" $FUNCNAME
	fi
	journalisation $FUNCNAME "$message"
	;;
0)
	dejournalisation $FUNCNAME
	;;
esac
}

test_mysql() {
# Cette fonction permet de verifier le bon fonctionnement du service mysql.
if [ ! -z $pass_mysql ]; then
	mysql -h $hote_mysql -u $user_mysql -p$pass_mysql -e quit 2> /dev/null
else
	mysql -h $hote_mysql -u $user_mysql -e quit 2> /dev/null
fi
if [ $? != 0 ]; then
	if [[ ( -z $ENVOI_DE_MAIL || $ENVOI_IMPRESSION ) ]]; then
		sortie=${repertoire_de_travail}/last_log.log
		echo "#monitoring - avertissement# Le service mysql sur $hote_mysql ne repond pas" > $sortie
		echo "${date_full}." >> $sortie
		echo "Test effectue depuis ${nom_serveur}." >> $sortie
		echo "La tentative de connexion a echoue avec l\'utilisateur ${user_mysql}." >> $sortie
		if [ -z $ENVOI_DE_MAIL ]; then
			envoi_de_mail $sortie $FUNCNAME
		fi
		if [ -z $ENVOI_IMPRESSION ]; then
			envoi_impression $sortie $FUNCNAME
		fi
	fi
	message="$nom_serveur : le serveur mysql $hote_mysql ne repond pas"
	if [ -z $ENVOI_DE_SMS ]; then
		envoi_de_sms "$message" $FUNCNAME
	fi
	journalisation $FUNCNAME "$message"
else
	dejournalisation $FUNCNAME
fi
}

supression_ftp() {
# Cette fonction supprime le fichier de log, de sauvegarde ou de dump devenu
# obsolete sur le serveur ftp.
if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
	echo "+++ Supression de fichier obsolete $1 sur ftp://${hote_ftp}." >> $2
	sortie=$2
else
	sortie=/dev/null
fi
if [ ! -z $repertoire_ftp ]; then
	echo -e "open $hote_ftp\nuser $login_ftp $pass_ftp\ncd $repertoire_ftp\nrm $1\nquit" > $repertoire_de_travail/script_file
else
	echo -e "open $hote_ftp\nuser $login_ftp $pass_ftp\nrm $1\nquit" > $repertoire_de_travail/script_file
fi
lftp -f $repertoire_de_travail/script_file >> $sortie 2>&1
if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
	if [ $? = 0 ]; then
		echo "Connexion ftp OK, supression du fichier." >> $sortie
		if [ ! -z $repertoire_ftp ]; then
			echo "=> ftp://${hote_ftp}/${repertoire_ftp}/${1}." >> $sortie
		else
			echo "=> ftp://${hote_ftp}/${1}." >> $sortie
		fi
	else
		echo "Echec de la connexion ftp sur ftp://${user_ftp}@${hote_ftp}." >> $sortie
		echo "Merci de supprimer le fichier manuellement."
		if [ ! -z $repertoire_ftp ]; then
			echo "=> ftp://${hote_ftp}/${repertoire_ftp}/${1}." >> $sortie
		else
			echo "=> ftp://${user_ftp}@${hote_ftp}/${1}." >> $sortie
		fi
	fi
fi
rm $repertoire_de_travail/script_file >> $sortie 2>&1
}

supression_smb() {
# Cette fonction supprime le fichier de log, de sauvegarde ou de dump devenu
# obsolete sur le partage smb.
if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
	echo "+++ Supression du fichier obsolete $1 sur //${hote_smb}/${partage_smb}." >> $2
	sortie=$2
else
	sortie=/dev/null
fi
mount.cifs //${hote_smb}/${partage_smb} $point_de_montage -o user=${login_smb},pass=${pass_smb},dom=${dom_smb} >> $sortie 2>&1
if [ $? = 0 ]; then
	echo "Montage OK, supression du fichier" >> $sortie
	if [ ! -z $sous_repertoire ]; then
		echo "=> //${hote_smb}/${partage_smb}/${sous_repertoire}/${1}." >> $sortie
	else
		echo "=> //${hote_smb}/${partage_smb}/${1}." >> $sortie
	fi
	if [ ! -z $sous_repertoire ]; then
		rm ${point_de_montage}/${sous_repertoire}/${1}
	else
		rm ${point_de_montage}/${1}
	fi
else
	echo "Echec au montage du partage //${hote_smb}/${partage_smb}." >> $sortie
	if [ ! -z $sous_repertoire ]; then
		echo "Merci de supprimer le fichier manuellement." >> $sortie
		echo "=> //${hote_smb}/${partage_smb}/${sous_repertoire}/${1}." >> $sortie
	else
		echo "Merci de supprimer le fichier manuellement." >> $sortie
		echo "=> //${hote_smb}/${partage_smb}/${1}." >> $sortie
	fi
fi
umount $point_de_montage
}

rotation_sauvegardes() {
# Cette fonction se charge de conserver uniquement le nombre de sauvegardes
# defini a l'avance. Elle supprime donc les sauvegardes depassant ce nombre en
# commencant par les plus anciennes.
fichier_log=${repertoire_sauvegarde}/log-$(date +%F).log
if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
	echo "+++ Rotation des ${2}s." >> $fichier_log
fi
if [ ! -z $3 ]; then
	declare -i nombre_sauvegardes=`ls -ltc $repertoire_sauvegarde | grep ${2} | grep ${3}-2 | wc -l`
	grepstring=${2}-${3}-2
else
	declare -i nombre_sauvegardes=`ls -ltc $repertoire_sauvegarde | grep ${2}-2 | wc -l`
	grepstring=${2}-2
fi
declare -i nombre_a_conserver=$nombre_a_conserver
if [ $nombre_sauvegardes -gt $nombre_a_conserver ]; then
	nombre_a_conserver=$(( $nombre_a_conserver + 1))
	for i in $(ls -ltc $repertoire_sauvegarde | grep $grepstring | tail -n +$nombre_a_conserver | awk '{print $9}'); do
		if [ -f ${repertoire_sauvegarde}/${i} ]; then
			if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
				echo "Supression du fichier $i" >> $fichier_log
				rm ${repertoire_sauvegarde}/${i} >> $fichier_log 2>&1
				echo "Rotation OK." >> $fichier_log
			else
				rm ${repertoire_sauvegarde}/${i} &> /dev/null
			fi
			if [ $utiliser_ftp = true ]; then
				supression_ftp $i $1
			fi
			if [ $utiliser_smb = true ]; then
				supression_smb $i $1
			fi
		fi
	done
else
	if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
		echo "Rotation inutile : nombre de ${2}s < ${nombre_a_conserver}." >> $fichier_log
	fi
fi
}

envoi_ftp() {
# Cette fonction envoie la derniere sauvegarde ou le dernier dump sur un serveur FTP.
if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
	if [ ! -z $repertoire_ftp ]; then
		echo "+++ Envoi par FTP des $2s. vers ftp://$hote_ftp/$repertoire_ftp/" >> $3
	else
		echo "+++ Envoi par FTP des $2s. vers ftp://$hote_ftp/" >> $3
	fi
	sortie=$3
else
	sortie=/dev/null
fi
message_echec_ftp="echec de l envoi du fichier par ftp -"
if [ ! -z $repertoire_ftp ]; then
	wput -q ftp://$login_ftp:$pass_ftp@$hote_ftp/$repertoire_ftp/ $1 >> $sortie 2>&1
else
	wput -q ftp://$login_ftp:$pass_ftp@$hote_ftp/ $1 >> $sortie 2>&1
fi
case $? in
2)
	if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
		echo "Echec de l\'envoi du fichier $1 par ftp." >> $sortie
		echo "Cause : probleme de connexion." >> $sortie
	fi
	message="$nom_serveur : $message_echec_ftp probleme de connexion"
	if [ -z $ENVOI_DE_SMS ]; then
		envoi_de_sms "$message"
	fi
	journalisation $FUNCNAME "$message"
	;;
1)
	if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
		echo "Echec de l\'envoi du fichier $1 par ftp." >> $sortie
		echo "Cause : le fichier existe deja." >> $sortie
	fi
	message="$nom_serveur : $message_echec_ftp le fichier existe deja"
	if [ -z $ENVOI_DE_SMS ]; then
		envoi_de_sms "$message"
	fi
	;;
0)
	echo "Reussite de l\'envoi du fichier $1 par ftp." >> $sortie
	if [ ! -z $repertoire_ftp ]; then
		echo "=> ftp://$hote_ftp/$repertoire_ftp/$1" >> $sortie
	else
		echo "=> ftp://$hote_ftp/$1" >> $sortie
	fi
	;;
esac
}

envoi_smb() {
# Cette fonction envoie la derniere sauvegarde ou le dernier dump sur un partage SMB.
if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
	if [ $2 = "dump" ]; then
		echo "+++ Envoi par SMB du $2." >> $3
	else
		echo "+++ Envoi par SMB de la $2." >> $3
	fi
	sortie=$3
else
	sortie=/dev/null
fi
mount.cifs //${hote_smb}/${partage_smb} $point_de_montage -o user=${login_smb},pass=${pass_smb},dom=${dom_smb} >> $sortie 2>&1
if [ $? = 0 ]; then
	echo "Montage OK, copie du fichier $(basename $1) sur le partage." >> $sortie
	if [ ! -z $sous_repertoire ]; then
		echo "=> //${hote_smb}/${partage_smb}/${sous_repertoire}/$(basename $1)." >> $sortie
		if [ ! -d ${point_de_montage}/${sous_repertoire} ]; then
			mkdir ${point_de_montage}/${sous_repertoire}
		fi
		if [ ! -f ${point_de_montage}/${sous_repertoire}/$(basename $1) ]; then
			cp  $1 ${point_de_montage}/${sous_repertoire}/
		fi
	else
		echo "=> //${hote_smb}/${partage_smb}/$(basename $1)." >> $sortie
		if [ ! -f ${point_de_montage}/$(basename $1) ]; then
			cp $1 ${point_de_montage}/
		fi
	fi
else
	echo "Echec au montage du partage //${hote_smb}/${partage_smb}." >> $sortie
	if [ ! -z $sous_repertoire ]; then
		echo "Merci de supprimer copier le fichier $1 dans le repertoire manuellement." >> $sortie
		echo "=> //${hote_smb}/${partage_smb}/${sous_repertoire}." >> $sortie
	else
		echo "Merci de supprimer copier le fichier $1 dans le repertoire manuellement." >> $sortie
		echo "=> //${hote_smb}/${partage_smb}." >> $sortie
	fi
fi
umount $point_de_montage
}

listing_repertoires() {
fichier_log=${repertoire_sauvegarde}/log-$(date +%F).log
declare -i compteur_repertoires=1
echo "=> ${1}" >> $fichier_log
while [ $compteur_repertoires -lt $# ]; do
	compteur_repertoires=$(( $compteur_repertoires + 1 ))
	echo "=> $(eval echo \$$compteur_repertoires)" >> $fichier_log
done
}

infos_serveur() {
echo "#############################################################." >> $1
echo "Serveur : $(uname -n) - $(uname -p)." >> $1
echo "Systeme : $(uname -o) $(uname -r) (ArchLinux)." >> $1
declare -i mem_dispo=$(free -m | grep + | awk '{print $4}')
declare -i mem_tot=$(free -m | grep Mem | awk '{print $2}')
echo "Memoire vive disponible : ${mem_dispo}/${mem_tot}Mo ($(( $mem_dispo * 100 / $mem_tot ))%)." >> $1
cmd_services=$(for i in `ps -u root u | grep -v ] | grep -v tty`; do if [ -f $i ]; then echo `basename $i` | grep -v sh$ | grep -v monitor; fi; done)
liste_services=$(echo $cmd_services | sed -e s/master/postfix/)
echo "Services actifs du systeme :" >> $1
echo "${liste_services}" >> $1
echo "$(df -h | head -n 1)" >> $1
declare -i compteur_infos=$(df -h | grep /dev/sd | wc -l)
while [ $compteur_infos -gt 0 ]; do
        echo "$(df -h | grep sd | head -n +$compteur_infos | tail -n 1)" >> $1
        compteur_infos=$(( $compteur_infos - 1 ))
done
echo "#############################################################." >> $1
}

sauvegarde() {
# Cette fonction, selon le cas, remplis le fichier de log, effectue un dump mysql ou encore
# compresse un ou plusieurs repertoires dans un fichier tar.gz.
# Une fois cette operation effectuee, la rotation des sauvegardes est declenchee.
case $2 in
log)
	echo "#monitoring# Rapport de sauvegarde de $nom_serveur - $(date +%d/%m/%y)" > $1
	echo " " >> $1
	infos_serveur $1
	echo " " >> $1
	echo "#############################################################." >> $1
	echo "     Rapport de sauvegarde du ${date_full}." >> $1
	echo "#############################################################." >> $1
	;;
dump)
	if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
		fichier_log=${repertoire_sauvegarde}/log-$(date +%F).log
		if [ ! -z $4 ]; then
			echo " " >> $fichier_log
			echo "-------------------------------------------------------------." >> $fichier_log
			echo "                 Sauvegarde des dumps MySQL." >> $fichier_log
			echo "-------------------------------------------------------------." >> $fichier_log
		fi
		echo " " >> $fichier_log
		echo "++++++ Dump de la base MySQL \"${3}\"." >> $fichier_log
	fi
	if [ ! -z $pass_mysql ]; then
		mysqldump -h $hote_mysql -u $user_mysql -p$pass_mysql $3 > $1
	else
		mysqldump -h $hote_mysql -u $user_mysql $3 > $1
	fi
	if [ $? = 0 ]; then
		if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
			echo "Reussite du dump de la base ${3}." >> $fichier_log
			echo "=> ${1}" >> $fichier_log
		fi
		rotation_sauvegardes $fichier_log $2 $3
		if [ $utiliser_ftp = true ]; then
			cd $repertoire_sauvegarde
			envoi_ftp `basename $fichier_sauvegarde` $2 $fichier_log
		fi
		if [ $utiliser_smb = true ]; then
			envoi_smb $fichier_sauvegarde $2 $fichier_log
		fi
	else
		message="$nom_serveur : echec du dump de la base $3 du $(date +%F) depuis le serveur ${hote_mysql}."
		if [ -z $ENVOI_DE_SMS ]; then
			envoi_de_sms "$message"
		fi
		if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
			echo "Echec du dump de la bases MySQL ${3}." >> $fichier_log
		fi
	fi
	;;
sauvegarde)
	if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
		fichier_log=${repertoire_sauvegarde}/log-$(date +%F).log
		echo " " >> $fichier_log
		echo "-------------------------------------------------------------." >> $fichier_log
		echo "                 Sauvegarde des repertoires." >> $fichier_log
		echo "-------------------------------------------------------------." >> $fichier_log
		echo " " >> $fichier_log
		echo "Liste des repertoires a sauvegarder :" >> $fichier_log
		listing_repertoires $repertoires_a_sauvegarder
		echo " " >> $fichier_log
		sortie=$fichier_log
	else
		sortie=/dev/null
	fi
	tar -zcpf $1 $repertoires_a_sauvegarder >> $sortie 2>&1
	if [ $? = 0 ]; then
		if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
			echo " " >> $fichier_log
			echo "Reussite de la sauvegarde des repertoires." >> $fichier_log
			echo " " >> $fichier_log
		fi
		rotation_sauvegardes $fichier_log $2
		if [ $utiliser_ftp = true ]; then
			cd $repertoire_sauvegarde
			envoi_ftp `basename $fichier_sauvegarde` $2 $fichier_log
		fi
		if [ $utiliser_smb = true ]; then
			envoi_smb $fichier_sauvegarde $2 $fichier_log
		fi
	else
		message="$nom_serveur : echec de la sauvegarde du(des) repertoire(s) $repertoires_a_sauvegarder du $(date +%F)."
		if [ -z $ENVOI_DE_SMS ]; then
			envoi_de_sms "$message"
		fi
		if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
			echo " " >> $fichier_log
			echo "Echec de la sauvegarde des repertoires." >> $fichier_log
			echo " " >> $fichier_log
		fi
	fi
	declare -i temps_final=$(date +%s)
	declare -i temps_total=$(( $temps_final - $temps_initial ))
	temps_h_m_s="$(( $temps_total / 3600 ))h $(( $temps_total % 3600 / 60 ))mn $(( $temps_total % 3600 % 60 ))s"
	echo " " >> $fichier_log
	echo "-------------------------------------------------------------." >> $fichier_log
	echo "        Duree totale de la sauvegarde : $temps_h_m_s." >> $fichier_log
	echo "-------------------------------------------------------------." >> $fichier_log
	echo " " >> $fichier_log
	echo "#############################################################." >> $fichier_log
	echo "                       Fin du rapport." >> $fichier_log
	echo "#############################################################." >> $fichier_log
	echo " " >> $fichier_log
	envoi_de_mail $fichier_log
	;;
esac
}

nommage_fichier_sauvegarde_2() {
# Cette fonction permet de renommer le fichier de sauvegarde si plusieurs sauvegardes sont effectuees
# le meme jour, on ajoute -2, -3 ... au nom du fichier.
# Cette fonction n'est pas executee pour les fichiers de log.
# Quoi qu'il en soit, on ne conserve, pour une journee donnee, que le fichier de log le plus recent.
if [ -f $1 ]; then
	fichier_sauvegarde=${1%.*}-2.${1##*.}
	declare -i compteur_nommage2=2
	while [ -f $fichier_sauvegarde ]; do
		compteur_nommage2=$(( $compteur_nommage2 + 1 ))
		fichier_sauvegarde=${fichier_sauvegarde%-*}-${compteur_nommage2}.${fichier_sauvegarde##*.}
	done
fi
if [ ! -z $4 ]; then
	sauvegarde $fichier_sauvegarde "$2" "$3" "$4"
else
	sauvegarde $fichier_sauvegarde "$2" "$3"
fi
}

nommage_fichier_sauvegarde() {
# Cette fonction permet de nommer le fichier de sauvegarde en fonction de la date
# selon qu'il s'agisse d'une sauvegarde de donnees, d'un dump mysql ou d'un log.
case $1 in
dump)
	declare -i compteur_nommage=1
	while [ $compteur_nommage -lt $# ]; do
		compteur_nommage=$(( $compteur_nommage + 1 ))
		fichier_sauvegarde="${repertoire_sauvegarde}/${1}-$(eval echo \$$compteur_nommage)-$(date +%F).sql"
		if [ $compteur_nommage = 2 ]; then
			nommage_fichier_sauvegarde_2 $fichier_sauvegarde $1 $(eval echo \$$compteur_nommage) "first"
		else
			nommage_fichier_sauvegarde_2 $fichier_sauvegarde $1 $(eval echo \$$compteur_nommage)
		fi
	done
	;;
sauvegarde)
	fichier_sauvegarde=${repertoire_sauvegarde}/${1}-$(date +%F).tgz
	nommage_fichier_sauvegarde_2 $fichier_sauvegarde $1
	;;
log)
	fichier_sauvegarde=${repertoire_sauvegarde}/${1}-$(date +%F).log
	sauvegarde $fichier_sauvegarde $1
	;;
esac
}

#####EXECUTION DU SCRIPT#####

if [ ! -f /root/monitoring/monitor.pid ]; then
	echo "Script monitor.x en courd d\'execution" > /root/monitoring/monitor.x.pid
else
	exit
fi
verification_jour_mois
verification_root
verification_connectivite
verification_repertoire_de_travail
if [ -z $VERIFICATION_ESPACE_DISQUE ]; then
	verification_espace_disque "$volumes"
fi
if [ -z $VERIFICATION_ETAT_DISQUES ]; then
	verification_etat_disques "$disques_durs"
fi
if [ -z $VERIFICATION_MEMOIRE_VIVE ]; then
	verification_memoire_vive
fi
if [[ ( -z $SAUVEGARDE && $1 = "-s" ) ]]; then
#if [[ ( -z $SAUVEGARDE && $(date +%H) = $heure_sauvegarde && $(date +%M) = $minute_sauvegarde && $(date +%u) != 1 && $(date +%u) != 7 ) ]]; then
	verification_repertoire_de_sauvegarde
	if [[ ( -z $ENVOI_DE_MAIL || -z $ENVOI_IMPRESSION ) ]]; then
		declare -i temps_initial=$(date +%s)
		export temps_initial
		nommage_fichier_sauvegarde "log"
	fi
	if [ ! -z "$bases_a_sauvegarder" ]; then
		nommage_fichier_sauvegarde "dump" $bases_a_sauvegarder
	fi
	if [ ! -z "$repertoires_a_sauvegarder" ]; then
		nommage_fichier_sauvegarde "sauvegarde"
	fi
fi
if [ -z $TEST_SERVEUR_SECONDAIRE ]; then
	test_serveur_secondaire
fi
if [ -z $TEST_MYSQL ]; then
	test_mysql
fi
fin_du_script
#####THAT'S ALL FOLKS !!#####
